#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 状态定义
typedef enum {
    SEARCH_HEADER,
    SEARCH_FOOTER
} ParserState;

// 包处理器结构体
typedef struct {
    unsigned char* buffer;    // 数据缓冲区
    size_t buf_size;          // 缓冲区大小
    size_t data_len;          // 当前数据长度
    ParserState state;        // 解析状态
} PacketParser;

// 初始化解析器
void parser_init(PacketParser* parser, size_t init_size) {
    parser->buffer = (unsigned char*)malloc(init_size);
    parser->buf_size = init_size;
    parser->data_len = 0;
    parser->state = SEARCH_HEADER;
}

// 扩展缓冲区
void expand_buffer(PacketParser* parser, size_t needed_size) {
    if (needed_size <= parser->buf_size) return;
    
    size_t new_size = parser->buf_size * 2;
    while (new_size < needed_size) new_size *= 2;
    
    unsigned char* new_buf = realloc(parser->buffer, new_size);
    if (!new_buf) {
        fprintf(stderr, "Memory allocation failed\n");
        exit(EXIT_FAILURE);
    }
    
    parser->buffer = new_buf;
    parser->buf_size = new_size;
}

// 处理输入数据
void process_data(PacketParser* parser, const unsigned char* data, size_t len) {
    for (size_t i = 0; i < len; ++i) {
        expand_buffer(parser, parser->data_len + 1);
        parser->buffer[parser->data_len++] = data[i];
    }
}

// 提取完整包
unsigned char* extract_packet(PacketParser* parser, size_t* pkt_len) {
    size_t start = 0;
    size_t end = 0;

    // 查找包头
    while (start < parser->data_len && parser->buffer[start] != 0xAA) {
        start++;
    }

    if (start >= parser->data_len) {
        // 没有包头，清空缓冲区
        parser->data_len = 0;
        return NULL;
    }

    // 查找包尾
    end = start + 1;
    while (end < parser->data_len && parser->buffer[end] != 0x2F) {
        end++;
    }

    if (end >= parser->data_len) {
        // 未找到包尾，保留剩余数据
        if (start > 0) {
            memmove(parser->buffer, parser->buffer + start, parser->data_len - start);
            parser->data_len -= start;
        }
        return NULL;
    }

    // 找到完整包
    *pkt_len = end - start + 1;
    unsigned char* packet = malloc(*pkt_len);
    memcpy(packet, parser->buffer + start, *pkt_len);

    // 处理剩余数据
    size_t remaining = parser->data_len - (end + 1);
    if (remaining > 0) {
        memmove(parser->buffer, parser->buffer + end + 1, remaining);
    }
    parser->data_len = remaining;

    return packet;
}


// 主处理函数
void process_hex_string(const char* hex_str) {
    // 转换十六进制字符串为字节数组
    size_t hex_len = strlen(hex_str); // 获取十六进制字符串的长度
    size_t byte_len = (hex_len + 1) / 3; // 计算字节数（每字节+空格）
    unsigned char* byte_data = malloc(byte_len); // 分配内存用于存储字节数组
    
    size_t byte_index = 0; // 初始化字节数组的索引
    for (size_t i = 0; i < hex_len; ) { // 遍历十六进制字符串
        if (hex_str[i] == ' ') { // 跳过空格字符
            i++;
            continue;
        }
        
        if (i+1 >= hex_len) break; // 如果剩余字符不足两个，退出循环
        
        char hex_byte[3] = {hex_str[i], hex_str[i+1], '\0'}; // 提取两个字符作为十六进制字节
        byte_data[byte_index++] = (unsigned char)strtol(hex_byte, NULL, 16); // 将十六进制字符串转换为字节并存储
        i += 2; // 移动到下一个字节位置
    }

    PacketParser parser; // 定义数据包解析器
    parser_init(&parser, 256); // 初始化解析器，缓冲区大小为256字节

    // 处理数据
    process_data(&parser, byte_data, byte_index); // 处理字节数据
    
    // 提取数据包
    while (1) {
        size_t pkt_len; // 数据包长度
        unsigned char* packet = extract_packet(&parser, &pkt_len); // 提取数据包
        if (!packet) break; // 如果没有数据包，退出循环

        // 打印结果
        // printf("Packet (%zu bytes): ", pkt_len); // 打印数据包长度
        for (size_t i = 0; i < pkt_len; ++i) { // 遍历数据包字节
            printf("%02X ", packet[i]); // 打印每个字节
        }
        printf("\n"); // 换行

        free(packet); // 释放数据包内存
    }

    // 清理资源
    free(byte_data); // 释放字节数组内存
    free(parser.buffer); // 释放解析器缓冲区内存
    
}
// 将十六进制字符串转换为字节数组 :aa->0xaa
char* hex_str_to_c_array(const char* hex_str) {
    // 创建可修改的字符串副本
    char* str_copy = strdup(hex_str);
    if (!str_copy) return NULL;

    // 计算最大可能的输出长度
    size_t max_len = strlen(hex_str) * 5 + 1; // 每个字节最多占5字符（"0xXX, "）
    char* result = malloc(max_len);
    if (!result) {
        free(str_copy);
        return NULL;
    }
    result[0] = '\0';

    // 分割字符串并处理每个token
    char* token = strtok(str_copy, " ");
    while (token != NULL) {
        // 转换为小写并验证长度
        if (strlen(token) != 2) {
            free(str_copy);
            free(result);
            return NULL;
        }

        // 构造新的格式
        char temp[6];
        snprintf(temp, sizeof(temp), "0x%02X%c", 
        (unsigned)strtol(token, NULL, 16),
        (strtok(NULL, " ") ? ',' : '\0'));

        strcat(result, temp);
        token = strtok(NULL, " ");
    }

    // 移除最后的逗号（如果有）
    size_t len = strlen(result);
    if (len > 0 && result[len-1] == ',') {
        result[len-1] = '\0';
    }

    free(str_copy);
    return result;
}

int main() {
    const char *hex_str = "AA 55 20 81 03 00 00 02 0D 0A 00 00 00 72 2F AA 07 21 81 03 00 00 02 03 5B 2F AA 02 22 00 CE 2F AA 02 24 00 D0 2F";

    process_hex_string(hex_str);//截包后输出

    // const char* hex_str = "AA 0B 27 00 00 00 00 00 00 00 02 81 01 00 60 2F";
    
    // char* formatted = hex_str_to_c_array(hex_str);

    return 0;
}
//作用：解出数据包

// gcc -o jiebao jiebao.c && jiebao.exe

